home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / fenv.h < prev    next >
C/C++ Source or Header  |  1996-05-01  |  13KB  |  285 lines
  1. /*******************************************************************************
  2. *                                                                              *
  3. *      File fenv.h - PowerPC and 68K                                           *
  4. *                                                                              *
  5. *      A collection of functions designed to provide access to the floating    *
  6. *      point environment for numerical programming. It is modeled after the    *
  7. *      Numerical C Extensions Group's requirements ( NCEG / X3J11.1 ).         *
  8. *                                                                              *
  9. *      The file <fenv.h> declares many functions in support of numerical       *
  10. *      programming.  It provides a set of environmental controls similar to    *
  11. *      the ones found in <SANE.h>.  Programs that test flags or run under      *
  12. *      non-default modes must do so under the effect of an enabling            *
  13. *      "fenv_access" pragma.                                                   *
  14. *                                                                              *
  15. *      Copyright © 1992-1995 Apple Computer, Inc.  All rights reserved.        *
  16. *                                                                              *
  17. *      Written by Ali Sazegari, started on October 1992.                       *
  18. *                                                                              *
  19. *      CHANGE LOG (most recent changes first)                                  *
  20. *                                                                              *
  21. *      17 Jan 95      ngk      Use ConditionalMacros for processor info        *
  22. *      13 May 94      PAF      Added fegetprec and fesetprec and               *
  23. *                              corresponding macros for 68K                    *
  24. *      22 Feb 94      PAF      Modified for 68K compatability                  *
  25. *      23 Aug 93      ali      included C++ extern "C" wrappers to make        *
  26. *                              them C++ friendly.                              *
  27. *      08 Apr 93      ali      changed "enums" to "macros" to be more          *
  28. *                              compatible with the FPCE of NCEG.               *
  29. *      05 Feb 93      JPO      Changed function types of feclearexcept,        *
  30. *                              fegetexcept, feraiseexcept, and fesetexcept     *
  31. *                              from int to void to reflect changes in NCEG     *
  32. *                              specification.  Changed definition of           *
  33. *                              FE_DFL_ENV from typedef to #define.  Modified   *
  34. *                              comments describing functionality.              *
  35. *                                                                              *
  36. *******************************************************************************/
  37.  
  38. #ifndef __FENV__
  39. #define __FENV__
  40.  
  41. #ifndef __CONDITIONALMACROS__
  42. #include <ConditionalMacros.h>
  43. #endif
  44.  
  45.  
  46. #if    GENERATINGPOWERPC
  47.  
  48. /*    The typedef fenv_t is a type for representing the entire floating-point
  49.       environment in a single object.                                         */
  50.  
  51. typedef      long int      fenv_t;
  52.  
  53. /*    The typedef fexcept_t is a type for representing the floating-point
  54.       exception flag state collectively.                                      */
  55.  
  56. typedef      long int      fexcept_t;
  57.  
  58. /*    Definitions of floating-point exception macros                          */
  59.  
  60. #define      FE_INEXACT         0x02000000
  61. #define      FE_DIVBYZERO       0x04000000
  62. #define      FE_UNDERFLOW       0x08000000
  63. #define      FE_OVERFLOW        0x10000000
  64. #define      FE_INVALID         0x20000000
  65.  
  66. /*    Definitions of rounding direction macros                                */
  67.  
  68. #define      FE_TONEAREST       0x00000000 
  69. #define      FE_TOWARDZERO      0x00000001 
  70. #define      FE_UPWARD          0x00000002 
  71. #define      FE_DOWNWARD        0x00000003
  72.  
  73. #endif    /* GENERATINGPOWERPC    */
  74.  
  75. #if GENERATING68K
  76.  
  77. #if GENERATING68881
  78.  
  79. typedef  long fexcept_t;
  80. typedef struct {
  81.     long FPCR;
  82.     long FPSR;
  83. } fenv_t;
  84.  
  85. #define      FE_INEXACT        ((long)(8))
  86. #define      FE_DIVBYZERO      ((long)(16))
  87. #define      FE_UNDERFLOW      ((long)(32))
  88. #define      FE_OVERFLOW       ((long)(64))
  89. #define      FE_INVALID        ((long)(128))
  90.  
  91. #else     
  92.  
  93. typedef  short fexcept_t;
  94. typedef  short fenv_t;
  95.  
  96. #define      FE_INVALID        ((short)(1))
  97. #define      FE_UNDERFLOW      ((short)(2))
  98. #define      FE_OVERFLOW       ((short)(4))
  99. #define      FE_DIVBYZERO      ((short)(8))
  100. #define      FE_INEXACT        ((short)(16))
  101.  
  102. #endif    /* GENERATING68881    */
  103.  
  104. #define FE_TONEAREST           ((short)(0))
  105. #define FE_UPWARD              ((short)(1))
  106. #define FE_DOWNWARD            ((short)(2))
  107. #define FE_TOWARDZERO          ((short)(3))
  108.  
  109. /*    Definitions of rounding precision macros  (68K only)                    */
  110.  
  111. #define FE_LDBLPREC            ((short)(0))
  112. #define FE_DBLPREC             ((short)(1))
  113. #define FE_FLTPREC             ((short)(2))
  114.  
  115. #endif    /* GENERATING68K    */
  116.  
  117. /*    The bitwise OR of all exception macros                                  */
  118.  
  119. #define      FE_ALL_EXCEPT     ( FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID )
  120.  
  121. /*    Definition of pointer to IEEE default environment object                */
  122.  
  123. extern fenv_t _FE_DFL_ENV;               /* default environment object        */
  124. #define FE_DFL_ENV &_FE_DFL_ENV          /* pointer to default environment    */
  125.  
  126.  
  127. #ifdef __cplusplus
  128. extern "C" {
  129. #endif
  130.  
  131. /*******************************************************************************
  132. *     The following functions provide access to the exception flags.  The      *
  133. *     "int" input argument can be constructed by bitwise ORs of the exception  *
  134. *     macros: for example: FE_OVERFLOW | FE_INEXACT.                           *
  135. *******************************************************************************/
  136.  
  137. /*******************************************************************************
  138. *     The function "feclearexcept" clears the supported exceptions represented *
  139. *     by its argument.                                                         *
  140. *******************************************************************************/
  141.  
  142. void feclearexcept ( int excepts );
  143.  
  144.  
  145.  
  146. /*******************************************************************************
  147. *    The function "fegetexcept" stores a representation of the exception       *
  148. *     flags indicated by the argument "excepts" through the pointer argument   *
  149. *     "flagp".                                                                 *
  150. *******************************************************************************/
  151.  
  152. void fegetexcept ( fexcept_t *flagp, int excepts );
  153.  
  154.  
  155.  
  156. /*******************************************************************************
  157. *     The function "feraiseexcept" raises the supported exceptions             *
  158. *     represented by its argument.                                             *
  159. *******************************************************************************/
  160.  
  161. void feraiseexcept ( int excepts );
  162.  
  163.  
  164.  
  165. /*******************************************************************************
  166. *     The function "fesetexcept" sets or clears the exception flags indicated  *
  167. *     by the int argument "excepts" according to the representation in the     *
  168. *     object pointed to by the pointer argument "flagp".  The value of         *
  169. *     "*flagp" must have been set by a previous call to "fegetexcept".         *
  170. *     This function does not raise exceptions; it just sets the state of       *
  171. *     the flags.                                                               *
  172. *******************************************************************************/
  173.  
  174. void fesetexcept ( const fexcept_t *flagp, int excepts );
  175.  
  176.  
  177.  
  178. /*******************************************************************************
  179. *     The function "fetestexcept" determines which of the specified subset of  *
  180. *     the exception flags are currently set.  The argument "excepts" specifies *
  181. *     the exception flags to be queried as a bitwise OR of the exception       *
  182. *     macros.  This function returns the bitwise OR of the exception macros    *
  183. *     corresponding to the currently set exceptions included in "excepts".     *
  184. *******************************************************************************/
  185.  
  186. int fetestexcept ( int excepts );
  187.  
  188.  
  189.  
  190. /*******************************************************************************
  191. *     The following functions provide control of rounding direction modes.     *
  192. *******************************************************************************/
  193.  
  194. /*******************************************************************************
  195. *     The function "fegetround" returns the value of the rounding direction    *
  196. *     macro which represents the current rounding direction.                   *
  197. *******************************************************************************/
  198.  
  199. int fegetround ( void );
  200.  
  201.  
  202.  
  203. /*******************************************************************************
  204. *     The function "fesetround" establishes the rounding direction represented *
  205. *     by its argument.  It returns nonzero if and only if the argument matches *
  206. *     a rounding direction macro.  If not, the rounding direction is not       *
  207. *     changed.                                                                 *
  208. *******************************************************************************/
  209.  
  210. int fesetround ( int round );
  211.  
  212.  
  213.  
  214. /*******************************************************************************
  215. *    The following functions manage the floating-point environment, exception  *
  216. *    flags and dynamic modes, as one entity.                                   *
  217. *******************************************************************************/
  218.  
  219. /*******************************************************************************
  220. *     The function "fegetenv" stores the current floating-point environment    *
  221. *     in the object pointed to by its pointer argument "envp".                 *
  222. *******************************************************************************/
  223.  
  224. void fegetenv ( fenv_t *envp );
  225.  
  226.  
  227.  
  228. /*******************************************************************************
  229. *     The function "feholdexcept" saves the current environment in the object  *
  230. *     pointed to by its pointer argument "envp", clears the exception flags,   *
  231. *     and clears floating-point exception enables.  This function supersedes   *
  232. *     the SANE function "procentry", but it does not change the current        *
  233. *     rounding direction mode.                                                 *
  234. *******************************************************************************/
  235.  
  236. int feholdexcept ( fenv_t *envp );
  237.  
  238.  
  239.  
  240. /*******************************************************************************
  241. *     The function "fesetenv" installs the floating-point environment          *
  242. *     environment represented by the object pointed to by its argument         *
  243. *     "envp".  The value of "*envp" must be set by a call to "fegetenv" or     *
  244. *     "feholdexcept", by an implementation-defined macro of type "fenv_t",     *
  245. *     or by the use of the pointer macro FE_DFL_ENV as the argument.           *
  246. *******************************************************************************/
  247.  
  248. void fesetenv ( const fenv_t *envp );
  249.  
  250.  
  251.  
  252. /*******************************************************************************
  253. *     The function "feupdateenv" saves the current exceptions into its         *
  254. *     automatic storage, installs the environment represented through its      *
  255. *     pointer argument "envp", and then re-raises the saved exceptions.        *
  256. *     This function, which supersedes the SANE function "procexit", can be     *
  257. *     used in conjunction with "feholdexcept" to write routines which hide     *
  258. *     spurious exceptions from their callers.                                  *
  259. *******************************************************************************/
  260.       
  261. void feupdateenv ( const fenv_t * envp );
  262.  
  263. #if GENERATING68K
  264.  
  265. /*******************************************************************************
  266. *     The following functions provide control of rounding precision.           *
  267. *     Because the PowerPC does not provide this capability, these functions    *  
  268. *     are available only for the 68K Macintosh.  Rounding precision values     *
  269. *     are defined by the rounding precision macros.  These functions are       *
  270. *     equivalent to the SANE functions getprecision and setprecision.          *
  271. *******************************************************************************/
  272.  
  273. int fegetprec ( void );
  274. int fesetprec ( int precision );
  275.  
  276. #endif  /* GENERATING68K */
  277.  
  278.  
  279. #ifdef __cplusplus
  280. }
  281. #endif
  282.  
  283.  
  284. #endif    /*  __FENV__ */
  285.